
/*
    Software License

    Copyright (C) 2021-05-24  Xoronos

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, version 3.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

/*
    Liabilities

    The software is provided "AS IS" without any warranty of any kind, either expressed,
    implied, or statutory, including, but not limited to, any warranty that the software
    will conform to specifications, any implied warranties of merchantability, fitness
    for a particular purpose, and freedom from infringement, and any warranty that the
    documentation will conform to the software, or any warranty that the software will
    be error free.

    In no event shall Xoronos be liable for any damages, including, but not limited to,
    direct, indirect, special or consequential damages, arising out of, resulting from,
    or in any way connected with this software, whether or not based upon warranty,
    contract, tort, or otherwise, whether or not injury was sustained by persons or
    property or otherwise, and whether or not loss was sustained from, or arose out of
    the results of, or use of, the software or services provided hereunder.

    To request the provided software under a different license you can contact us at
    support@xoronos.com
*/

#include "lexhelp.h"
#include "lexhelp_backend.h"
#include "lexexample_backend.h"
#include "lexexample.h"
#include "lexcheck.h"

void lex_help_print_commands( int current_command, char *all_args[]
 )
{
    int noline;
    char buffer[256];

    noline = 2;

    if ( current_command == XH_HELP ) {
        strncpy( buffer, "xrnlib-cli --help ", 256 );
    } else if ( current_command == XE_EXAMPLE ) {
        strncpy( buffer, "xrnlib-cli --example ", 256 );
    } else if ( current_command == XS_SCRIPT ) {
        strncpy( buffer, "xrnlib-cli --script ", 256 );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "########################################################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "# the list of all the possible commands is shown below #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "########################################################\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "####################################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# classical key exchange functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "####################################\n" );
    XLEX_PRINT(  );

    lex_help_print_make_start_point( buffer, all_args, noline );
    lex_help_print_make_monomial_key( buffer, all_args, noline );
    lex_help_print_make_binomial_key( buffer, all_args, noline );
    lex_help_print_exchange_monomial_key( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "##################################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# quantum key exchange functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "##################################\n" );
    XLEX_PRINT(  );

    lex_help_print_make_monovalent_key( buffer, all_args, noline );
    lex_help_print_exchange_polyvalent_key( buffer, all_args, noline );
    lex_help_print_check_monovalent_key( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "#####################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# ciphers functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "#####################\n" );
    XLEX_PRINT(  );

    lex_help_print_split_symmetric( buffer, all_args, noline );
    lex_help_print_encrypt_asymmetric( buffer, all_args, noline );
    lex_help_print_encrypt_symmetric( buffer, all_args, noline );
    lex_help_print_join_symmetric( buffer, all_args, noline );
    lex_help_print_decipher_asymmetric( buffer, all_args, noline );
    lex_help_print_decipher_symmetric( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "################################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# hash and checksums functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "################################\n" );
    XLEX_PRINT(  );

    lex_help_print_make_hash( buffer, all_args, noline );
    lex_help_print_make_checksum( buffer, all_args, noline );
    lex_help_print_check_checksum( buffer, all_args, noline );
    lex_help_print_check_hash( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "#########################################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# signatures and certificates functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "#########################################\n" );
    XLEX_PRINT(  );

    lex_help_print_make_signature_symmetric( buffer, all_args, noline );
    lex_help_print_make_signature_asymmetric( buffer, all_args, noline );
    lex_help_print_make_ring_signature( buffer, all_args, noline );
    lex_help_print_permute_ring_signature( buffer, all_args, noline );
    lex_help_print_make_certificate_symmetric( buffer, all_args, noline );
    lex_help_print_make_certificate_asymmetric( buffer, all_args, noline );
    lex_help_print_check_signature_symmetric( buffer, all_args, noline );
    lex_help_print_check_signature_asymmetric( buffer, all_args, noline );
    lex_help_print_check_ring_signature( buffer, all_args, noline );
    lex_help_print_check_certificate_symmetric( buffer, all_args, noline );
    lex_help_print_check_certificate_asymmetric( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "############################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# encoding layer functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "############################\n" );
    XLEX_PRINT(  );

    lex_help_print_dump_encoding_param( buffer, all_args, noline );
    lex_help_print_decode_encode( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "############################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# sequence layer functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "############################\n" );
    XLEX_PRINT(  );

    lex_help_print_mine_xmatrix_comp_rnd( buffer, all_args, noline );
    lex_help_print_mine_xmatrix_comp_ot( buffer, all_args, noline );
    lex_help_print_permute_xmatrix_comp_random( buffer, all_args, noline );
    lex_help_print_permute_xmatrix_comp_deterministic( buffer, all_args, noline );
    lex_help_print_permute_xmatrix_comp_confidential( buffer, all_args, noline );
    lex_help_print_decompress_xmatrix( buffer, all_args, noline );
    lex_help_print_check_xmatrix_comp( buffer, all_args, noline );
    lex_help_print_check_xmatrix( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "###############################################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# confidential pseudo random number functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "###############################################\n" );
    XLEX_PRINT(  );

    lex_help_print_make_point( buffer, all_args, noline );
    lex_help_print_make_confidential_pseudo_random_number( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "##############################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# block management functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "##############################\n" );
    XLEX_PRINT(  );

    lex_help_print_check_complete_blocks( buffer, all_args, noline );
    lex_help_print_make_block( buffer, all_args, noline );
    lex_help_print_merge_block( buffer, all_args, noline );
    lex_help_print_strip_header_from_block( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "##################################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# zero knowledge proof functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "##################################\n" );
    XLEX_PRINT(  );

    lex_help_print_make_commitment_binomial_key( buffer, all_args, noline );
    lex_help_print_make_commitment_sym_signature( buffer, all_args, noline );
    lex_help_print_make_commitment_sym_certificate( buffer, all_args, noline );
    lex_help_print_make_response( buffer, all_args, noline );
    lex_help_print_make_monomial_proof( buffer, all_args, noline );
    lex_help_print_make_monomial_proof_sym_signature( buffer, all_args, noline );
    lex_help_print_make_monomial_proof_sym_certificate( buffer, all_args, noline );
    lex_help_print_check_monomial_proof( buffer, all_args, noline );
    lex_help_print_check_monomial_proof_sym_signature( buffer, all_args, noline );
    lex_help_print_check_monomial_proof_sym_certificate( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "###########################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# steganography functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "###########################\n" );
    XLEX_PRINT(  );

    lex_help_print_get_capacity( buffer, all_args, noline );
    lex_help_print_make_steganography_block( buffer, all_args, noline );
    lex_help_print_extract_steganography_block( buffer, all_args, noline );
    lex_help_print_make_steganography_raw( buffer, all_args, noline );
    lex_help_print_extract_steganography_raw( buffer, all_args, noline );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "#####################\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "# utility functions #\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "#####################\n" );
    XLEX_PRINT(  );

    lex_help_print_convert_hash_to_monomial_key( buffer, all_args, noline );
    lex_help_print_convert_hash_to_point( buffer, all_args, noline );
    lex_help_print_convert_point_to_monomial_key( buffer, all_args, noline );
    lex_help_print_convert_monomial_key_to_point( buffer, all_args, noline );
    lex_help_print_convert_binomial_key_to_start_point( buffer, all_args, noline );
    lex_help_print_convert_start_point_to_point( buffer, all_args, noline );
    lex_help_print_convert_point_to_start_point( buffer, all_args, noline );
    lex_help_print_convert_monomial_key_to_monomial_commitment( buffer, all_args, noline );
    lex_help_print_convert_monomial_commitment_to_monomial_key( buffer, all_args, noline );
    lex_help_print_convert_symmetric_certificate_to_monovalent_key( buffer, all_args, noline );
    lex_help_print_convert_asymmetric_certificate_to_binomial_key( buffer, all_args, noline );
    lex_help_print_convert_asymmetric_signature_to_binomial_key( buffer, all_args, noline );
    lex_help_print_convert_symmetric_signature_to_binomial_key( buffer, all_args, noline );
    lex_help_print_convert_binomial_key_to_asymmetric_signature( buffer, all_args, noline );
    lex_help_print_convert_binomial_key_to_symmetric_signature( buffer, all_args, noline );
    lex_help_print_print_header( buffer, all_args, noline );
    lex_help_print_print_lib_info( buffer, all_args, noline );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_encoding_conf( int dump_encoding_param, char *all_args[]
 )
{
    lex_help_print_encoding_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%-48s%s either %s %s %s should be specified\n", LEXTAB,
              LEXTAB, all_args[XEC_ENCODING_PARAM], all_args[XEC_COMPILED_PARAM], all_args[XEC_NO_PARAM] );
    XLEX_PRINT(  );
    if ( dump_encoding_param == 1 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%-48s%s either %s %s should be specified\n", LEXTAB,
                  LEXTAB, all_args[XEC_PASSWORD_STR], all_args[XEC_INIT_FILE] );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_ENCODING_PARAM],
              "to use a file storing encoding paramethers\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XEC_ENCODING_PARAM] );
    XLEX_PRINT(  );
    lex_print_path_option( XEC_ENCODING_PARAM, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s ", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    lex_print_path_option( XEC_ENCODING_PARAM, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "can be generated using %s\n",
              all_args[XDEP_DUMP_ENCODING_PARAM] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_COMPILED_PARAM],
              "to use compiled encoding paramethers\n" );
    XLEX_PRINT(  );
    if ( dump_encoding_param == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_NO_PARAM],
                  "to do not use encoding paramethers\n" );
        XLEX_PRINT(  );
    }

    if ( dump_encoding_param == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_NO_PASSWORD],
                  "to do not use a password\n" );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_INIT_FILE],
              "to use an initialization file for encoding paramethers\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XEC_INIT_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XEC_INIT_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_PASSWORD_STR],
              "to specify a password string\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s Password123#\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XEC_PASSWORD_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_NO_RUNNING_ERR],
              "disable running checks\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_RUNNING_ERR_TH],
              "running error threshold (how many consecutive ones/zeros)\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 36\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XEC_RUNNING_ERR_TH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 36, allowed range 27..45\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_RUNNING_WAR_TH],
              "running warning threshold (how many consecutive ones/zeros)\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 32\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XEC_RUNNING_WAR_TH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 32, allowed range 24..44\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_NO_DISPARITY_ERR],
              "disable disparity checks\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_DISPARITY_ERR_TH],
              "disparity error (how many ones/zeros in a buffer of 1024 bits)\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 704\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XEC_DISPARITY_ERR_TH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 704, allowed range 480..800\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEC_DISPARITY_WAR_TH],
              "disparity warning (how many ones/zeros in a buffer of 1024 bits)\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 640\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XEC_DISPARITY_WAR_TH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 640, allowed range 528..880 \n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );
};

void lex_help_decoding_conf( char *all_args[]
 )
{
    lex_help_print_decoding_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%-48s%s either %s %s %s should be specified\n", LEXTAB,
              LEXTAB, all_args[XDC_ENCODING_PARAM], all_args[XDC_COMPILED_PARAM], all_args[XDC_NO_PARAM] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_ENCODING_PARAM],
              "to use a file storing encoding paramethers\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDC_ENCODING_PARAM] );
    XLEX_PRINT(  );
    lex_print_path_option( XDC_ENCODING_PARAM, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s ", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    lex_print_path_option( XDC_ENCODING_PARAM, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "can be generated using %s\n",
              all_args[XDEP_DUMP_ENCODING_PARAM] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_COMPILED_PARAM],
              "to use compiled encoding paramethers\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_NO_PARAM],
              "to do not use encoding paramethers\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_NO_PASSWORD],
              "to do not use a password\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_INIT_FILE],
              "to use an initialization file for encoding paramethers\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDC_INIT_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XDC_INIT_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_PASSWORD_STR],
              "to specify a password string\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s Password123#\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XDC_PASSWORD_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_NO_RUNNING_ERR],
              "disable running checks\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_RUNNING_ERR_TH],
              "running error threshold (how many consecutive ones/zeros)\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 36\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XDC_RUNNING_ERR_TH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 36, allowed range 27..45\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_RUNNING_WAR_TH],
              "running warning threshold (how many consecutive ones/zeros)\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 32\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XDC_RUNNING_WAR_TH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 32, allowed range 24..44\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_NO_DISPARITY_ERR],
              "disable disparity checks\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_DISPARITY_ERR_TH],
              "disparity error (how many ones/zeros in a buffer of 1024 bits)\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 704\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XDC_DISPARITY_ERR_TH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 704, allowed range 480..800\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDC_DISPARITY_WAR_TH],
              "disparity warning (how many ones/zeros in a buffer of 1024 bits)\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 640\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XDC_DISPARITY_WAR_TH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 640, allowed range 528..880 \n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );
};

void lex_help_logging_conf( int mandatory_response, char *all_args[]
 )
{

    lex_help_print_loggining_conf( all_args, 0 );

    if ( mandatory_response == 1 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_LIB_INFO_LOG],
                  "the information log is required for the current command\n" );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
                  all_args[XLC_LIB_INFO_LOG] );
        XLEX_PRINT(  );
        lex_print_path_option( XLC_LIB_INFO_LOG, 0, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_FORCE_APPEND],
              "open all the log files in append mode, this option will\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, LEXTAB,
              "automatically keep the previous log information\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_FORCE_WRITE],
              "open all the output files in write mode\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_COMMAND_LINE_LOG],
              "command line information log\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XLC_COMMAND_LINE_LOG] );
    XLEX_PRINT(  );
    lex_print_path_option( XLC_COMMAND_LINE_LOG, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_LIB_ERROR_LOG],
              "error output of the library\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XLC_LIB_ERROR_LOG] );
    XLEX_PRINT(  );
    lex_print_path_option( XLC_LIB_ERROR_LOG, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_LIB_WARNING_LOG],
              "warning output of the library\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XLC_LIB_WARNING_LOG] );
    XLEX_PRINT(  );
    lex_print_path_option( XLC_NO_LIB_WARNING_LOG, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_LIB_DEBUG_LOG],
              "debug output of the library\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XLC_LIB_DEBUG_LOG] );
    XLEX_PRINT(  );
    lex_print_path_option( XLC_LIB_DEBUG_LOG, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_DEBUG_SEED],
              "seed to identify current command run\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s %d\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XLC_LIB_DEBUG_LOG], rand(  ) );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_NO_COMMAND_LINE_LOG],
              "no output messages from the lexer\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_NO_LIB_ERROR_LOG],
              "no output error messages from the library\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XLC_NO_LIB_WARNING_LOG],
              "no output warning messages from the library\n" );
    XLEX_PRINT(  );

}

void lex_help_dump_encoding_param( char *all_args[]
 )
{
    int mandatory_response;

    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_encoding_conf( 1, all_args );
    lex_help_logging_conf( mandatory_response, all_args );
    lex_help_print_dump_encoding_param( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDEP_ENCODING_PARAM],
              "the output encoding paramethers\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDEP_ENCODING_PARAM] );
    XLEX_PRINT(  );
    lex_print_path_option( XDEP_ENCODING_PARAM, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_decode_encode_param( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );
    lex_help_logging_conf( mandatory_response, all_args );
    lex_help_print_decode_encode( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDE_TO_DECODE],
              "the input file to decode\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDE_TO_DECODE] );
    XLEX_PRINT(  );
    lex_print_path_option( XDE_TO_DECODE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDE_TO_ENCODE],
              "the output file to encode\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDE_TO_ENCODE] );
    XLEX_PRINT(  );
    lex_print_path_option( XDE_TO_ENCODE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
}

void lex_help_mine_xmatrix_comp_rand( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s rule: the %s should be specified if the\n", LEXTAB,
              LEXTAB, all_args[XDC_DECODING_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s option is specified", LEXTAB, LEXTAB,
              all_args[XMXCR_PSEUDO_RANDOM] );
    XLEX_PRINT(  );
    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );
    lex_help_logging_conf( mandatory_response, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s rule: the %s should be specified if the\n",
              LEXTAB, LEXTAB, all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s option is specified", LEXTAB, LEXTAB,
              all_args[XMXCR_PSEUDO_RANDOM] );
    XLEX_PRINT(  );
    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_POINT, XMP_MAKE_POINT, "the input point file\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );

    lex_help_print_arch( all_args );

    lex_help_print_mine_xmatrix_comp_rnd( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCR_PROB_ONES],
              "the probability to set a bit in the genesis matrix to one\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 0.005\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XMXCR_PROB_ONES] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 0.005, allowed range [0.001 .. 0.5]\n",
              LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCR_MAX_TRIES],
              "the maximum number of tries in the stochastic mining process\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 50000\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XMXCR_MAX_TRIES] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 50000, allowed range [1000 .. 100000]\n",
              LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCR_XMATRIX_COMP],
              "the output Xoron matrix compressed\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMXCR_XMATRIX_COMP] );
    XLEX_PRINT(  );
    lex_print_path_option( XMXCR_XMATRIX_COMP, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s rule: the %s should be specified\n", LEXTAB, LEXTAB,
              all_args[XMXCR_XMATRIX_COMP] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCR_RANDOM],
              "if the mining process should be random\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCR_PSEUDO_RANDOM],
              "if the mining process should be pseudo random\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the %s should be specified if %s is specified\n", LEXTAB, LEXTAB,
              all_args[XAC_POINT], all_args[XMXCR_PSEUDO_RANDOM] );
    XLEX_PRINT(  );

}

void lex_help_mine_xmatrix_comp_ot( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s rule: the %s should be specified if the\n", LEXTAB,
              LEXTAB, all_args[XDC_DECODING_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s option is specified", LEXTAB, LEXTAB,
              all_args[XMXCO_PSEUDO_RANDOM] );
    XLEX_PRINT(  );
    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );
    lex_help_logging_conf( mandatory_response, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s rule: the %s should be specified if the\n",
              LEXTAB, LEXTAB, all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s option is specified", LEXTAB, LEXTAB,
              all_args[XMXCO_PSEUDO_RANDOM] );
    XLEX_PRINT(  );
    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_POINT, XMP_MAKE_POINT, "the input point file\n", all_args );
    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_print_mine_xmatrix_comp_ot( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCO_MIN_ONES_PER_ROW],
              "the minimum number of bits set to one per row in the genesis matrix\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 2\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XMXCO_MIN_ONES_PER_ROW] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 2, allowed range [0 .. %s]\n", LEXTAB,
              LEXTAB, all_args[XMXCO_MAX_ONES_PER_ROW] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCO_MAX_ONES_PER_ROW],
              "the maximum number of bits set to one per row in the genesis matrix\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 5\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XMXCO_MAX_ONES_PER_ROW] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 5, allowed range [%s .. 15]\n", LEXTAB,
              LEXTAB, all_args[XMXCO_MIN_ONES_PER_ROW] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCO_MAX_TRIES],
              "the maximum number of tries in the stochastic mining process\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 50000\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XMXCO_MAX_TRIES] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 50000, allowed range [1000 .. 100000]\n",
              LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCO_XMATRIX_COMP],
              "the output Xoron matrix compressed\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMXCO_XMATRIX_COMP] );
    XLEX_PRINT(  );
    lex_print_path_option( XMXCO_XMATRIX_COMP, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s rule: the %s should be specified\n", LEXTAB, LEXTAB,
              all_args[XMXCO_XMATRIX_COMP] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCO_RANDOM],
              "if the mining process should be random\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMXCO_PSEUDO_RANDOM],
              "if the mining process should be pseudo random\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the %s should be specified if %s is specified\n", LEXTAB, LEXTAB,
              all_args[XAC_POINT], all_args[XMXCO_PSEUDO_RANDOM] );
    XLEX_PRINT(  );

}

void lex_help_permute_xmatrix_comp_random( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;

    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX_COMP, XMXCR_MINE_XMATRIX_COMP_RND,
                                   "the input Xoron matrix compressed to permute\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_permute_xmatrix_comp_random( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPXCR_XMATRIX_COMP_DST],
              "the destination Xoron matrix compressed permuted\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPXCR_XMATRIX_COMP_DST] );
    XLEX_PRINT(  );
    lex_print_path_option( XPXCR_XMATRIX_COMP_DST, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_permute_xmatrix_comp_deterministic( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX_COMP, XMXCR_MINE_XMATRIX_COMP_RND,
                                   "the input Xoron matrix compressed to permute\n", all_args );

    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_permute_xmatrix_comp_deterministic( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPXCD_XMATRIX_COMP_DST],
              "the destination Xoron matrix compressed permuted\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPXCD_XMATRIX_COMP_DST] );
    XLEX_PRINT(  );
    lex_print_path_option( XPXCD_XMATRIX_COMP_DST, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_permute_xmatrix_comp_confidential( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the monomial key (private key)\n", all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX_COMP, XMXCR_MINE_XMATRIX_COMP_RND,
                                   "the input Xoron matrix compressed to permute\n", all_args );

    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_permute_xmatrix_comp_confidential( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPXCS_XMATRIX_COMP_DST],
              "the destination Xoron matrix compressed permuted\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPXCS_XMATRIX_COMP_DST] );
    XLEX_PRINT(  );
    lex_print_path_option( XPXCS_XMATRIX_COMP_DST, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_decompress_xmatrix( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX_COMP, XMXCR_MINE_XMATRIX_COMP_RND,
                                   "the input Xoron matrix compressed to permute\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_decompress_xmatrix( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDX_XMATRIX],
              "the decompressed Xoron matrix file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDX_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XDX_XMATRIX, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_xmatrix_comp( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 1;
    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX_COMP, XMXCR_MINE_XMATRIX_COMP_RND,
                                   "the input Xoron matrix compressed to check\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_xmatrix_comp( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_xmatrix( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 1;
    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX, "the input Xoron matrix to check\n",
                                   all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_xmatrix( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_point( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_point( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMP_POINT],
              "the point file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMP_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMP_POINT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_confidential_pseudo_random_number( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_POINT, XMP_MAKE_POINT, "the input point\n", all_args );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY, "the input key\n", all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_confidential_pseudo_random_number( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSPRN_NEXT_POINT],
              "the output point file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSPRN_NEXT_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSPRN_NEXT_POINT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_start_point( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );

    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_start_point( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSP_START_POINT],
              "the start point file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSP_START_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSP_START_POINT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_monomial_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_monomial_key( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMK_MONOMIAL_KEY],
              "the monomial key file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMK_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMK_MONOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_binomial_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    mandatory_response = 0;
    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_START_POINT, XMSP_MAKE_START_POINT,
                                   "the starting point of the pseudo random sequence\n", all_args );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the distance to traverse the pseudo random sequence (also know as private key)\n",
                                   all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_binomial_key( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMBK_BINOMIAL_KEY],
              "the output binomial key storing the start and end point \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMBK_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMBK_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_exchange_monomial_key( char *all_args[]
 )
{
    int mandatory_response;

    mandatory_response = 0;
    char buffer[256];

    strncpy( buffer, "", 256 );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY,
                                   "the binomial key generated with your secret monomial key\n", all_args );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY, "your secret monomial key\n",
                                   all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_exchange_monomial_key( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEMK_EXTERNAL_BINOMIAL_KEY],
              "the input binomial key given by another user \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XEMK_EXTERNAL_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XEMK_EXTERNAL_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEMK_SHARED_MONOMIAL_KEY],
              "the output monomial key (the shared secret) \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XEMK_SHARED_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XEMK_SHARED_MONOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_monovalent_key( char *all_args[]
 )
{
    char buffer[256];
    int mandatory_response;
    time_t t;

    mandatory_response = 0;
    strncpy( buffer, "", 256 );
    time( &t );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_monovalent_key( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMK_MONOVALENT_KEY],
              "the output monovalent key (public quantum key) \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMK_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMK_MONOVALENT_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMK_POLYVALENT_KEY],
              "the output polyvalent key (private quantum key) \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMK_POLYVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMK_POLYVALENT_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMK_POLYVALENT_PROOF],
              "the output polyvalent proof used to validate the monovalent key \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMK_POLYVALENT_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMK_POLYVALENT_PROOF, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMK_START_TIMESTAMP],
              "the input start of the monovalent key validity in posix time \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s %lu\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMK_START_TIMESTAMP], ( uint64_t ) t );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMK_END_TIMESTAMP],
              "the input end of the monovalent key validity in posix time \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s %lu ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMK_END_TIMESTAMP], ( uint64_t ) ( t + 600 ) );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_exchange_polyvalent_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_POLYVALENT_KEY, XMMK_MAKE_MONOVALENT_KEY,
                                   "the input polyvalent key (secret key)\n", all_args );
    lex_help_back_print_ac_option( XAC_POLYVALENT_PROOF, XMMK_MAKE_MONOVALENT_KEY,
                                   "the input polyvalent proof (used to verify a monovalent key without revealing the polyvalent key)\n",
                                   all_args );
    lex_help_back_print_ac_option( XAC_MONOVALENT_KEY, XMMK_MAKE_MONOVALENT_KEY,
                                   "the input monovalent key (public key)\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_exchange_polyvalent_key( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEPK_EXTERNAL_MONOVALENT_KEY],
              "the input exchanged monovalent key \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XEPK_EXTERNAL_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XEPK_EXTERNAL_MONOVALENT_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEPK_SHARED_POLYVALENT_KEY],
              "the output exchanged secret key \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XEPK_SHARED_POLYVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XEPK_SHARED_POLYVALENT_KEY, 0, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_monovalent_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_POLYVALENT_PROOF, XMMK_MAKE_MONOVALENT_KEY,
                                   "the input polyvalent proof (used to verify a monovalent key without revealing the polyvalent key)\n",
                                   all_args );
    lex_help_back_print_ac_option( XAC_MONOVALENT_KEY, XMMK_MAKE_MONOVALENT_KEY,
                                   "the input monovalent key (public key)\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_monovalent_key( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_commitment_binomial_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY,
                                   "the binomial key to prove ownership over\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_commitment_binomial_key( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCBK_MONOMIAL_COMMITMENT],
              "the output secret monomial commitment \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCBK_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCBK_MONOMIAL_COMMITMENT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCBK_BINOMIAL_COMMITMENT],
              "the output public binomial commitment \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCBK_BINOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCBK_BINOMIAL_COMMITMENT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_commitment_sym_signature( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_SYM_SIGNATURE, XMSS_MAKE_SIGNATURE_SYMMETRIC,
                                   "the input signature file\n", all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_commitment_sym_signature( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCSS_MONOMIAL_COMMITMENT],
              "the output secret monomial commitment \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCSS_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSS_MONOMIAL_COMMITMENT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCSS_BINOMIAL_COMMITMENT],
              "the output public binomial commitment \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCSS_BINOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSS_BINOMIAL_COMMITMENT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCSS_PLAIN_TEXT],
              "the input plain text file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_commitment_sym_certificate( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_SYM_CERTIFICATE, XMCS_MAKE_CERTIFICATE_SYMMETRIC,
                                   "the input certificate file\n", all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_commitment_sym_certificate( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCSC_MONOMIAL_COMMITMENT],
              "the output secret monomial commitment \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCSC_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSC_MONOMIAL_COMMITMENT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCSC_BINOMIAL_COMMITMENT],
              "the output public binomial commitment \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCSC_BINOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSC_BINOMIAL_COMMITMENT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_response( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_response( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMR_MONOMIAL_RESPONSE],
              "the monomial response file to a commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMR_MONOMIAL_RESPONSE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMR_MONOMIAL_RESPONSE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_monomial_proof( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_KEY],
              "the monomial key associated to the binomial key\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_BINOMIAL_KEY],
              "the binomial key to prove ownership over\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_COMMITMENT],
              "the secret monomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_RESPONSE],
              "the monomial response to the binomial commitment\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX, "the input Xoron matrix\n",
                                   all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_monomial_proof( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMP_MONOMIAL_PROOF],
              "the output monomial proof to the binomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMP_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMP_MONOMIAL_PROOF, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_monomial_proof_sym_signature( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_SYM_SIGNATURE],
              "the symmetric signature to prove ownership over\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_KEY],
              "the monomial key associated to the binomial key\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_COMMITMENT],
              "the secret monomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_RESPONSE],
              "the monomial response to the binomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX, "the input Xoron matrix\n",
                                   all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_monomial_proof_sym_signature( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMPSS_MONOMIAL_PROOF],
              "the output monomial proof to the binomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMPSS_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMPSS_MONOMIAL_PROOF, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMPSS_PLAIN_TEXT],
              "the input plain text used to generate the symmetric signature\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMPSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMPSS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_monomial_proof_sym_certificate( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_SYM_CERTIFICATE],
              "the symmetric certificate to prove ownership over\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_COMMITMENT],
              "the secret monomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_KEY],
              "the monomial key associated to the binomial key\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_RESPONSE],
              "the monomial response to the binomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX, "the input Xoron matrix\n",
                                   all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_monomial_proof_sym_certificate( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMPSC_MONOMIAL_PROOF],
              "the output monomial proof to the binomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMMPSC_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMPSC_MONOMIAL_PROOF, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_monomial_proof( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_BINOMIAL_KEY],
              "the input public binomial key to verify ownership over\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_BINOMIAL_COMMITMENT],
              "the input binomial commitment associated with the binomial key\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_RESPONSE],
              "the input monomial response to the binomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_PROOF],
              "the input monomial proof given the monomial response\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX, "the input Xoron matrix\n",
                                   all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_monomial_proof( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_monomial_proof_sym_signature( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_BINOMIAL_COMMITMENT],
              "the input public binomial commitment associated with the symmetric signature\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_RESPONSE],
              "the input monomial response to the binomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_PROOF],
              "the input monomial proof given the monomial response\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_SYM_SIGNATURE],
              "the symmetric signature to prove ownership over\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX, "the input Xoron matrix\n",
                                   all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_monomial_proof_sym_signature( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMMPSS_PLAIN_TEXT],
              "the input plain text used to generate the symmetric signature\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCMPSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCMPSS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_monomial_proof_sym_certificate( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_BINOMIAL_COMMITMENT],
              "the input public binomial commitment associated to the symmetric certificate\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_RESPONSE],
              "the input monomial response to the binomial commitment\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_MONOMIAL_PROOF],
              "the input monomial proof given the monomial response\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_SYM_CERTIFICATE],
              "the symmetric certificate to prove ownership over\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX, "the input Xoron matrix\n",
                                   all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_monomial_proof_sym_certificate( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_signature_symmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the monomial key (private key)\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_STATE_SIZE],
              "the size of the data block for the cross traverse\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 4\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_STATE_SIZE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s the number of bits for the block is (state_size+1)*architecture\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 4, allowed range 4..255\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_signature_symmetric( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSS_PLAIN_TEXT],
              "the input file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSS_SYMMETRIC_SIGNATURE],
              "the output symmetric signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSS_SYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSS_SYMMETRIC_SIGNATURE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_signature_asymmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the input monomial key (private key)\n", all_args );
    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY,
                                   "the input binomial key (public key)\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_STATE_SIZE],
              "the size of the data block for the cross traverse\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 4\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_STATE_SIZE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s the number of bits for the block is (state_size+1)*architecture\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 4, allowed range 4..255\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_signature_asymmetric( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSA_PLAIN_TEXT],
              "the input file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSA_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSA_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSA_ASYMMETRIC_SIGNATURE],
              "the output asymmetric signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSA_ASYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSA_ASYMMETRIC_SIGNATURE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_permute_ring_signature( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_permute_ring_signature( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPRS_SIGNER_BINOMIAL_KEY],
              "the signer binomial key file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPRS_SIGNER_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_SIGNER_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPRS_VERIFIER_BINOMIAL_KEY],
              "the verifier binomial key file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPRS_VERIFIER_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_VERIFIER_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPRS_SIGNER_RING_SIGNATURE],
              "the signer ring signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPRS_SIGNER_RING_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_SIGNER_RING_SIGNATURE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPRS_VERIFIER_RING_SIGNATURE],
              "the verifier ring signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPRS_VERIFIER_RING_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_VERIFIER_RING_SIGNATURE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPRS_PERMUTED_RING_SIGNATURE],
              "the permuted ring signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPRS_PERMUTED_RING_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_PERMUTED_RING_SIGNATURE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_ring_signature( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the input monomial key (private key)\n", all_args );
    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY,
                                   "the input binomial key (public key)\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_STATE_SIZE],
              "the size of the data block for the cross traverse\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 4\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_STATE_SIZE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s the number of bits for the block is (state_size+1)*architecture\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 4, allowed range 4..255\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_ring_signature( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMRS_PLAIN_TEXT],
              "the input file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMRS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMRS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMRS_VERIFIER_BINOMIAL_KEY],
              "the input binomial key of the verifier of the ring signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMRS_VERIFIER_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMRS_VERIFIER_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMRS_ADD_DECOY_BINOMIAL_KEY],
              "the input binomial key of the verifier of the ring signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMRS_ADD_DECOY_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMRS_ADD_DECOY_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the number of decoys need to be at least 3 and at most 254\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMRS_RING_SIGNATURE],
              "the output ring signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMRS_RING_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMRS_RING_SIGNATURE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_certificate_symmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    time_t t;

    time( &t );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the input monomial key (private key)\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_STATE_SIZE],
              "the size of the data block for the cross traverse\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 4\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_STATE_SIZE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s the number of bits for the block is (state_size+1)*architecture\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 4, allowed range 4..255\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_certificate_symmetric( buffer, all_args, 0 );

    lex_help_back_print_ac_option( XMCS_SUBJECT_MONOVALENT_KEY, XMMK_MAKE_MONOVALENT_KEY,
                                   "the input subject monovalent key to be put in the certificate \n",
                                   all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCS_SUBJECT_STR],
              "the subject string associated with the monovalent key\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s \"Alice monovalent key\"\n", LEXTAB, LEXTAB,
              "usage: " );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCS_START_TIMESTAMP],
              "the input start of the symmetric certificate validity in posix time \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s %lu\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCS_START_TIMESTAMP], ( uint64_t ) t );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCS_END_TIMESTAMP],
              "the input end of the symmetric certificate validity in posix time \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s %lu ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCS_END_TIMESTAMP], ( uint64_t ) ( t + 600 ) );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCS_SYMMETRIC_CERTIFICATE],
              "the output symmetric certificate file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCS_SYMMETRIC_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCS_SYMMETRIC_CERTIFICATE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_certificate_asymmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    time_t t;

    time( &t );

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the input monomial key (private key)\n", all_args );
    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY,
                                   "the binomial key generated with your secret monomial key\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_RND_STR],
              "an optional random string to affect internal randomness\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"$(echo $RANDOM | base64)\"\n", LEXTAB,
              LEXTAB, "usage: ", all_args[XAC_RND_STR] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s rule: the string should be at most 255 characters long\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_STATE_SIZE],
              "the size of the data block for the cross traverse\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 4\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_STATE_SIZE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s the number of bits for the block is (state_size+1)*architecture\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 4, allowed range 4..255\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_certificate_asymmetric( buffer, all_args, 0 );

    lex_help_back_print_ac_option( XMCA_SUBJECT_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY,
                                   "the input subject binomial key to be put in the certificate \n",
                                   all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCS_SUBJECT_STR],
              "the subject string associated with the binomial key\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s \"Alice binomial key\"\n", LEXTAB, LEXTAB,
              "usage: ", all_args[XMCA_SUBJECT_STR] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCA_START_TIMESTAMP],
              "the input start of the asymmetric certificate validity in posix time \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s %lu\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCA_START_TIMESTAMP], ( uint64_t ) t );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCA_END_TIMESTAMP],
              "the input end of the asymmetric certificate validity in posix time \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s %lu ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCA_END_TIMESTAMP], ( uint64_t ) ( t + 600 ) );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMCA_ASYMMETRIC_CERTIFICATE],
              "the output asymmetric certificate file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMCA_ASYMMETRIC_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCA_ASYMMETRIC_CERTIFICATE, 0, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_signature_symmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the monomial key (private key)\n", all_args );
    lex_help_back_print_ac_option( XAC_SYM_SIGNATURE, XMSS_MAKE_SIGNATURE_SYMMETRIC,
                                   "the symmetric signature\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_signature_symmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCSS_PLAIN_TEXT],
              "the input plain text \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCSS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_signature_asymmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY, "the binomial key\n", all_args );
    lex_help_back_print_ac_option( XAC_ASY_SIGNATURE, XMSA_MAKE_SIGNATURE_ASYMMETRIC,
                                   "the asymmetric signature\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_signature_asymmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCSA_PLAIN_TEXT],
              "the input plain text \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCSA_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCSA_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_ring_signature( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the monomial key (private key)\n", all_args );
    lex_help_back_print_ac_option( XAC_RING_SIGNATURE, XMRS_MAKE_RING_SIGNATURE,
                                   "the ring signature\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_ring_signature( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCRS_PLAIN_TEXT],
              "the input plain text \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCRS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCRS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCRS_SIGNER_BINOMIAL_KEY],
              "the output signer of the signature\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCRS_SIGNER_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCRS_SIGNER_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_certificate_symmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the monomial key (private key)\n", all_args );
    lex_help_back_print_ac_option( XAC_SYM_CERTIFICATE, XMCS_MAKE_CERTIFICATE_SYMMETRIC,
                                   "the symmetric certificate\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_certificate_symmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_certificate_asymmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY, "the binomial key\n", all_args );
    lex_help_back_print_ac_option( XAC_ASY_CERTIFICATE, XMCA_MAKE_CERTIFICATE_ASYMMETRIC,
                                   "the asymmetric certificate\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_certificate_asymmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_hash( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );

    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_STATE_SIZE],
              "the size of the data block for the cross traverse\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 4\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_STATE_SIZE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s the number of bits for the block is (state_size+1)*architecture\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 4, allowed range 4..255\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_hash( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMH_HASH],
              "the output hash file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMH_HASH] );
    XLEX_PRINT(  );
    lex_print_path_option( XMH_HASH, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMH_PLAIN_TEXT],
              "the input plain text file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMH_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMH_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_hash( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_HASH, XMH_MAKE_HASH, "the input hash file\n", all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_THREAD],
              "do not use multiple threads to speed up the computation\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_NO_CONST_EXEC_TIME],
              "do not use the constant time execution version of the matrix traverse\n" );
    XLEX_PRINT(  );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_hash( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCH_PLAIN_TEXT],
              "the input plain text file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCH_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCH_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_checksum( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_logging_conf( mandatory_response, all_args );
    lex_help_print_make_checksum( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMC_CHECKSUM_TEXT],
              "the output checksum file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMC_CHECKSUM_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMC_CHECKSUM_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMC_PLAIN_TEXT],
              "the input plain text file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMC_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMC_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_checksum( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_logging_conf( mandatory_response, all_args );
    lex_help_print_check_checksum( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCC_PLAIN_TEXT],
              "the input plain text file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCC_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCC_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCC_CHECKSUM_TEXT],
              "the input checksum file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCC_CHECKSUM_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCC_CHECKSUM_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_hash_to_monomial_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_HASH, XMH_MAKE_HASH, "the input hash file\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_hash_to_monomial_key( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCHTMK_MONOMIAL_KEY],
              "the output monomial key file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCHTMK_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCHTMK_MONOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_hash_to_point( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_HASH, XMH_MAKE_HASH, "the input hash file\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_hash_to_point( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCHTP_POINT],
              "the output point file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCHTP_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCHTP_POINT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_point_to_monomial_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_POINT, XMP_MAKE_POINT, "the input point file\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_point_to_monomial_key( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCPTMK_MONOMIAL_KEY],
              "the output monomial key file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCPTMK_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCPTMK_MONOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_monomial_key_to_point( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "input the monomial key\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_monomial_key_to_point( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCMKTP_POINT],
              "the output point file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCMKTP_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCMKTP_POINT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_binomial_key_to_start_point( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY, "the input binomial key\n",
                                   all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );
    lex_help_print_convert_binomial_key_to_start_point( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCBKTSP_START_POINT],
              "the output start point file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCBKTSP_START_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCBKTSP_START_POINT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_start_point_to_point( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_START_POINT, XMSP_MAKE_START_POINT, "the input start point\n",
                                   all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_start_point_to_point( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCSPTP_POINT],
              "the output point file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCSPTP_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCSPTP_POINT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_point_to_start_point( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_POINT, XMP_MAKE_POINT, "the input point file\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_point_to_start_point( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCPTSP_START_POINT],
              "the output start point file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCPTSP_START_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCPTSP_START_POINT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_monomial_key_to_monomial_commitment( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "input the monomial key\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_monomial_key_to_monomial_commitment( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCMKTMC_MONOMIAL_COMMITMENT],
              "the output monomial commitment file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCMKTMC_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCMKTMC_MONOMIAL_COMMITMENT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_symmetric_certificate_to_monovalent_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_SYM_CERTIFICATE, XMCS_MAKE_CERTIFICATE_SYMMETRIC,
                                   "input the symmetric certificate\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_symmetric_certificate_to_monovalent_key( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCSCTMK_MONOVALENT_KEY],
              "the output monovalent key file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCSCTMK_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCSCTMK_MONOVALENT_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_asymmetric_certificate_to_binomial_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_ASY_CERTIFICATE, XMCA_MAKE_CERTIFICATE_ASYMMETRIC,
                                   "input the asymmetric certificate\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_asymmetric_certificate_to_binomial_key( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCACTBK_BINOMIAL_KEY],
              "the output binomial key file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCACTBK_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCACTBK_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_asymmetric_signature_to_binomial_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_ASY_SIGNATURE, XMSA_MAKE_SIGNATURE_ASYMMETRIC,
                                   "input the asymmetric signature\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_asymmetric_signature_to_binomial_key( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCASTBK_BINOMIAL_KEY],
              "the output binomial key file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCASTBK_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCASTBK_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_symmetric_signature_to_binomial_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_SYM_SIGNATURE, XMSS_MAKE_SIGNATURE_SYMMETRIC,
                                   "input the symmetric signature\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_symmetric_signature_to_binomial_key( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCSSTBK_BINOMIAL_KEY],
              "the output binomial key file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCSSTBK_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCSSTBK_BINOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_binomial_key_to_asymmetric_signature( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY,
                                   "input the binomial key\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_binomial_key_to_asymmetric_signature( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCBKTAS_ASYMMETRIC_SIGNATURE],
              "the output asymmetric signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCBKTAS_ASYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XCBKTAS_ASYMMETRIC_SIGNATURE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_binomial_key_to_symmetric_signature( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY,
                                   "input the binomial key\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_binomial_key_to_symmetric_signature( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCBKTSS_SYMMETRIC_SIGNATURE],
              "the output symmetric signature file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCBKTSS_SYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XCBKTSS_SYMMETRIC_SIGNATURE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_convert_monomial_commitment_to_monomial_key( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    lex_help_back_print_ac_option( XAC_MONOMIAL_COMMITMENT, XMCBK_MAKE_COMMITMENT_BINOMIAL_KEY,
                                   "input the monomial commitment\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_convert_monomial_commitment_to_monomial_key( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCMCTMK_MONOMIAL_KEY],
              "the output monomial key file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCMCTMK_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCMCTMK_MONOMIAL_KEY, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_split_symmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_STATE_SIZE],
              "the size of the data block \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 4\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_STATE_SIZE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s the number of bits for the block is (state_size+1)*architecture\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 4, allowed range 4..255\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_CRC_BITS],
              "the size of the crc checksum to write in the cipher text\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 32\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_CRC_BITS] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 32, allowed values 8, 16, 32, 64\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_split_symmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XSS_PLAIN_TEXT],
              "the input plain text \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XSS_CHALLENGE_TEXT],
              "the output challenge cipher (big file) \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XSS_CHALLENGE_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSS_CHALLENGE_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XSS_SOLUTION_TEXT],
              "the output solution cipher (small file) \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XSS_SOLUTION_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSS_SOLUTION_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_join_symmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_join_symmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XSS_PLAIN_TEXT],
              "the output plain text \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XSS_CHALLENGE_TEXT],
              "the input challenge cipher (big file) \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XSS_CHALLENGE_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSS_CHALLENGE_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XSS_SOLUTION_TEXT],
              "the input solution cipher (small file) \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XSS_SOLUTION_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSS_SOLUTION_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_encrypt_symmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_STATE_SIZE],
              "the size of the data block \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 4\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_STATE_SIZE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s the number of bits for the block is (state_size+1)*architecture\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 4, allowed range 4..255\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_CRC_BITS],
              "the size of the crc checksum to write in the cipher text\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 32\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_CRC_BITS] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 32, allowed values 8, 16, 32, 64\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the monomial key (private key)\n", all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_encrypt_symmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XES_PLAIN_TEXT],
              "the input plain text \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XES_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XES_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XES_CIPHER_TEXT],
              "the output cipher text file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XES_CIPHER_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XES_CIPHER_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_encrypt_asymmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_encoding_conf( 0, all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_STATE_SIZE],
              "the size of the data block \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 4\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_STATE_SIZE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s the number of bits for the block is (state_size+1)*architecture\n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 4, allowed range 4..255\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XAC_CRC_BITS],
              "the size of the crc checksum to write in the cipher text\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 32\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XAC_CRC_BITS] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s default 32, allowed values 8, 16, 32, 64\n", LEXTAB,
              LEXTAB );
    XLEX_PRINT(  );

    lex_help_back_print_ac_option( XAC_BINOMIAL_KEY, XMBK_MAKE_BINOMIAL_KEY,
                                   "the input binomial key\n", all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_encrypt_asymmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEA_PLAIN_TEXT],
              "the input plain text \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XEA_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XEA_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XEA_CIPHER_TEXT],
              "the output cipher text file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XEA_CIPHER_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XEA_CIPHER_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_decipher_asymmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the monomial key (private key)\n", all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_decipher_asymmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDA_PLAIN_TEXT],
              "the output plain text \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDA_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XDA_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDA_CIPHER_TEXT],
              "the input cipher text file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDA_CIPHER_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XDA_CIPHER_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_decipher_symmetric( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );

    lex_help_print_arithmetic_conf( all_args, 0 );
    lex_help_back_print_ac_option( XAC_MONOMIAL_KEY, XMMK_MAKE_MONOMIAL_KEY,
                                   "the monomial key (private key)\n", all_args );

    lex_help_print_sequence_conf( all_args, 0 );
    lex_help_back_print_ac_option( XSC_XMATRIX, XDX_DECOMPRESS_XMATRIX,
                                   "the input Xoron matrix decompressed\n", all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_decipher_symmetric( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDS_PLAIN_TEXT],
              "the output plain text \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XDS_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XDS_CIPHER_TEXT],
              "the input cipher text file \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XDS_CIPHER_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XDS_CIPHER_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_check_complete_blocks( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_check_complete_blocks( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCCB_BLOCK_FILE],
              "the input block file to assess if contains the entire content \n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCCB_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XCCB_BLOCK_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_block( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_block( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMB_OFFSET],
              "the offset in bytes of the plain text input file to start copying from\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 0 ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMB_OFFSET] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMB_LENGTH],
              "the length in bytes of the output block file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 64 ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMB_LENGTH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMB_TAG],
              "the tag is used to assess if the blocks belong to the same input plain text file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 0 ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMB_TAG] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMB_PLAIN_TEXT],
              "the input plain text file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMB_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMB_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMB_BLOCK_FILE],
              "the output block file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMB_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMB_BLOCK_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_merge_block( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_logging_conf( mandatory_response, all_args );
    lex_help_print_merge_block( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCB_BLOCK_FILE],
              "the input block file (there should be at least 2 blocks per command)\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCB_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XCB_BLOCK_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XCB_COMBINED_BLOCK_FILE],
              "the output block file with both the primary and secondary files merged\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XCB_COMBINED_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XCB_COMBINED_BLOCK_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_strip_header_from_block( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_logging_conf( mandatory_response, all_args );
    lex_help_print_strip_header_from_block( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XSHFB_BLOCK_FILE],
              "the input block with the block header\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XSHFB_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XSHFB_BLOCK_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XSHFB_PLAIN_TEXT],
              "the output plain text file without block header\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XSHFB_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSHFB_PLAIN_TEXT, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_print_header( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_decoding_conf( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_permutation_conf( all_args, 0 );
    lex_help_print_arch( all_args );

    lex_help_print_print_header( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPH_XRN_FILE],
              "the input Xoron file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPH_XRN_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XPH_XRN_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_print_lib_info( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_logging_conf( mandatory_response, all_args );
    lex_help_print_print_lib_info( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_get_capacity( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 1;

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_get_capacity( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XGC_ENVELOP_FILE],
              "the input envelop file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XGC_ENVELOP_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XGC_ENVELOP_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XGC_DISABLE_FOLDING],
              "do not assume that the source file has been encoded\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_steganography_raw( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_steganography_raw( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSR_SOURCE_FILE],
              "the input file to put in the envelop file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSR_SOURCE_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSR_SOURCE_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSR_ENVELOP_FILE],
              "the input envelop file to embed the raw file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSR_ENVELOP_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSR_ENVELOP_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSR_EMBEDDED_FILE],
              "the output embedded file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSR_EMBEDDED_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSR_EMBEDDED_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_make_steganography_block( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_encoding_conf( 0, all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_make_steganography_block( buffer, all_args, 0 );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSB_OFFSET],
              "the offset in bytes of the plain text input file to start copying from\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 0 ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSB_OFFSET] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSB_LENGTH],
              "the length in bytes of the output block file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 64 ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSB_LENGTH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSB_TAG],
              "the tag is used to assess if the blocks belong to the same input plain text file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 0 ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSB_TAG] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSB_DISABLE_FOLDING],
              "do not assume that the source file has been encoded\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSB_SOURCE_FILE],
              "the input file to put in the block\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSB_SOURCE_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSB_SOURCE_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSB_ENVELOP_FILE],
              "the input envelop file to embed the block\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSB_ENVELOP_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSB_ENVELOP_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XMSB_EMBEDDED_FILE],
              "the output embedded block file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XMSB_EMBEDDED_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSB_EMBEDDED_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_extract_steganography_raw( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_extract_steganography_raw( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XESR_EMBEDDED_FILE],
              "the input file containing an embedded raw file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XESR_EMBEDDED_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XESR_EMBEDDED_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XESR_RAW_FILE],
              "the output raw file\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XESR_RAW_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XESR_RAW_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_help_extract_steganography_block( char *all_args[]
 )
{
    int mandatory_response;
    char buffer[256];

    strncpy( buffer, "", 256 );
    mandatory_response = 0;

    lex_help_decoding_conf( all_args );
    lex_help_logging_conf( mandatory_response, all_args );

    lex_help_print_extract_steganography_block( buffer, all_args, 0 );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XESB_EMBEDDED_FILE],
              "the input file containing an embedded block\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XESB_EMBEDDED_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XESB_EMBEDDED_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XESB_BLOCK_FILE],
              "the output extracted block\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XESB_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XESB_BLOCK_FILE, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lexhelp_all( int command, char *all_args[]
 )
{

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\nhelp page associated with the %s command\n",
              all_args[command] );
    XLEX_PRINT(  );

    if ( command == XDC_DECODING_CONF ) {
    } else if ( command == XEC_ENCODING_CONF ) {
    } else if ( command == XAC_ARITHMETIC_CONF ) {
    } else if ( command == XSC_SEQUENCE_CONF ) {
    } else if ( command == XPC_PERMUTATION_CONF ) {
    } else if ( command == XLC_LOGGING_CONF ) {
    } else if ( command == XDEP_DUMP_ENCODING_PARAM ) {
        lex_help_dump_encoding_param( all_args );
    } else if ( command == XDE_DECODE_ENCODE ) {
        lex_help_decode_encode_param( all_args );
    } else if ( command == XMXCR_MINE_XMATRIX_COMP_RND ) {
        lex_help_mine_xmatrix_comp_rand( all_args );
    } else if ( command == XMXCO_MINE_XMATRIX_COMP_OT ) {
        lex_help_mine_xmatrix_comp_ot( all_args );
    } else if ( command == XPXCR_PERMUTE_XMATRIX_COMP_RANDOM ) {
        lex_help_permute_xmatrix_comp_random( all_args );
    } else if ( command == XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC ) {
        lex_help_permute_xmatrix_comp_deterministic( all_args );
    } else if ( command == XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL ) {
        lex_help_permute_xmatrix_comp_confidential( all_args );
    } else if ( command == XDX_DECOMPRESS_XMATRIX ) {
        lex_help_decompress_xmatrix( all_args );
    } else if ( command == XCXC_CHECK_XMATRIX_COMP ) {
        lex_help_check_xmatrix_comp( all_args );
    } else if ( command == XCX_CHECK_XMATRIX ) {
        lex_help_check_xmatrix( all_args );
    } else if ( command == XMP_MAKE_POINT ) {
        lex_help_make_point( all_args );
    } else if ( command == XMSPRN_MAKE_CONFIDENTIAL_PSEUDO_RANDOM_NUMBER ) {
        lex_help_make_confidential_pseudo_random_number( all_args );
    } else if ( command == XMSP_MAKE_START_POINT ) {
        lex_help_make_start_point( all_args );
    } else if ( command == XMMK_MAKE_MONOMIAL_KEY ) {
        lex_help_make_monomial_key( all_args );
    } else if ( command == XMBK_MAKE_BINOMIAL_KEY ) {
        lex_help_make_binomial_key( all_args );
    } else if ( command == XEMK_EXCHANGE_MONOMIAL_KEY ) {
        lex_help_exchange_monomial_key( all_args );
    } else if ( command == XMMK_MAKE_MONOVALENT_KEY ) {
        lex_help_make_monovalent_key( all_args );
    } else if ( command == XEPK_EXCHANGE_POLYVALENT_KEY ) {
        lex_help_exchange_polyvalent_key( all_args );
    } else if ( command == XCMK_CHECK_MONOVALENT_KEY ) {
        lex_help_check_monovalent_key( all_args );
    } else if ( command == XMCBK_MAKE_COMMITMENT_BINOMIAL_KEY ) {
        lex_help_make_commitment_binomial_key( all_args );
    } else if ( command == XMCSS_MAKE_COMMITMENT_SYM_SIGNATURE ) {
        lex_help_make_commitment_sym_signature( all_args );
    } else if ( command == XMCSC_MAKE_COMMITMENT_SYM_CERTIFICATE ) {
        lex_help_make_commitment_sym_certificate( all_args );
    } else if ( command == XMR_MAKE_RESPONSE ) {
        lex_help_make_response( all_args );
    } else if ( command == XMMP_MAKE_MONOMIAL_PROOF ) {
        lex_help_make_monomial_proof( all_args );
    } else if ( command == XMMPSS_MAKE_MONOMIAL_PROOF_SYM_SIGNATURE ) {
        lex_help_make_monomial_proof_sym_signature( all_args );
    } else if ( command == XMMPSC_MAKE_MONOMIAL_PROOF_SYM_CERTIFICATE ) {
        lex_help_make_monomial_proof_sym_certificate( all_args );
    } else if ( command == XCMP_CHECK_MONOMIAL_PROOF ) {
        lex_help_check_monomial_proof( all_args );
    } else if ( command == XCMPSS_CHECK_MONOMIAL_PROOF_SYM_SIGNATURE ) {
        lex_help_check_monomial_proof_sym_signature( all_args );
    } else if ( command == XCMPSC_CHECK_MONOMIAL_PROOF_SYM_CERTIFICATE ) {
        lex_help_check_monomial_proof_sym_certificate( all_args );
    } else if ( command == XMSS_MAKE_SIGNATURE_SYMMETRIC ) {
        lex_help_make_signature_symmetric( all_args );
    } else if ( command == XMSA_MAKE_SIGNATURE_ASYMMETRIC ) {
        lex_help_make_signature_asymmetric( all_args );
    } else if ( command == XPRS_PERMUTE_RING_SIGNATURE ) {
        lex_help_permute_ring_signature( all_args );
    } else if ( command == XMRS_MAKE_RING_SIGNATURE ) {
        lex_help_make_ring_signature( all_args );
    } else if ( command == XMCS_MAKE_CERTIFICATE_SYMMETRIC ) {
        lex_help_make_certificate_symmetric( all_args );
    } else if ( command == XMCA_MAKE_CERTIFICATE_ASYMMETRIC ) {
        lex_help_make_certificate_asymmetric( all_args );
    } else if ( command == XCSS_CHECK_SIGNATURE_SYMMETRIC ) {
        lex_help_check_signature_symmetric( all_args );
    } else if ( command == XCSA_CHECK_SIGNATURE_ASYMMETRIC ) {
        lex_help_check_signature_asymmetric( all_args );
    } else if ( command == XCRS_CHECK_RING_SIGNATURE ) {
        lex_help_check_ring_signature( all_args );
    } else if ( command == XCCS_CHECK_CERTIFICATE_SYMMETRIC ) {
        lex_help_check_certificate_symmetric( all_args );
    } else if ( command == XCCA_CHECK_CERTIFICATE_ASYMMETRIC ) {
        lex_help_check_certificate_asymmetric( all_args );
    } else if ( command == XMH_MAKE_HASH ) {
        lex_help_make_hash( all_args );
    } else if ( command == XMC_MAKE_CHECKSUM ) {
        lex_help_make_checksum( all_args );
    } else if ( command == XCC_CHECK_CHECKSUM ) {
        lex_help_check_checksum( all_args );
    } else if ( command == XCH_CHECK_HASH ) {
        lex_help_check_hash( all_args );
    } else if ( command == XCHTP_CONVERT_HASH_TO_POINT ) {
        lex_help_convert_hash_to_point( all_args );
    } else if ( command == XCHTMK_CONVERT_HASH_TO_MONOMIAL_KEY ) {
        lex_help_convert_hash_to_monomial_key( all_args );
    } else if ( command == XCPTMK_CONVERT_POINT_TO_MONOMIAL_KEY ) {
        lex_help_convert_point_to_monomial_key( all_args );
    } else if ( command == XCMKTP_CONVERT_MONOMIAL_KEY_TO_POINT ) {
        lex_help_convert_monomial_key_to_point( all_args );
    } else if ( command == XCBKTSP_CONVERT_BINOMIAL_KEY_TO_START_POINT ) {
        lex_help_convert_binomial_key_to_start_point( all_args );
    } else if ( command == XCSPTP_CONVERT_START_POINT_TO_POINT ) {
        lex_help_convert_start_point_to_point( all_args );
    } else if ( command == XCPTSP_CONVERT_POINT_TO_START_POINT ) {
        lex_help_convert_point_to_start_point( all_args );
    } else if ( command == XCMKTMC_CONVERT_MONOMIAL_KEY_TO_MONOMIAL_COMMITMENT ) {
        lex_help_convert_monomial_key_to_monomial_commitment( all_args );
    } else if ( command == XCMCTMK_CONVERT_MONOMIAL_COMMITMENT_TO_MONOMIAL_KEY ) {
        lex_help_convert_monomial_commitment_to_monomial_key( all_args );
    } else if ( command == XCSCTMK_CONVERT_SYMMETRIC_CERTIFICATE_TO_MONOVALENT_KEY ) {
        lex_help_convert_symmetric_certificate_to_monovalent_key( all_args );
    } else if ( command == XCACTBK_CONVERT_ASYMMETRIC_CERTIFICATE_TO_BINOMIAL_KEY ) {
        lex_help_convert_asymmetric_certificate_to_binomial_key( all_args );
    } else if ( command == XCASTBK_CONVERT_ASYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY ) {
        lex_help_convert_asymmetric_signature_to_binomial_key( all_args );
    } else if ( command == XCSSTBK_CONVERT_SYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY ) {
        lex_help_convert_symmetric_signature_to_binomial_key( all_args );
    } else if ( command == XCBKTAS_CONVERT_BINOMIAL_KEY_TO_ASYMMETRIC_SIGNATURE ) {
        lex_help_convert_binomial_key_to_asymmetric_signature( all_args );
    } else if ( command == XCBKTSS_CONVERT_BINOMIAL_KEY_TO_SYMMETRIC_SIGNATURE ) {
        lex_help_convert_binomial_key_to_symmetric_signature( all_args );
    } else if ( command == XSS_SPLIT_SYMMETRIC ) {
        lex_help_split_symmetric( all_args );
    } else if ( command == XEA_ENCRYPT_ASYMMETRIC ) {
        lex_help_encrypt_asymmetric( all_args );
    } else if ( command == XES_ENCRYPT_SYMMETRIC ) {
        lex_help_encrypt_symmetric( all_args );
    } else if ( command == XJS_JOIN_SYMMETRIC ) {
        lex_help_join_symmetric( all_args );
    } else if ( command == XDA_DECIPHER_ASYMMETRIC ) {
        lex_help_decipher_asymmetric( all_args );
    } else if ( command == XDS_DECIPHER_SYMMETRIC ) {
        lex_help_decipher_symmetric( all_args );
    } else if ( command == XCCB_CHECK_COMPLETE_BLOCK ) {
        lex_help_check_complete_blocks( all_args );
    } else if ( command == XMB_MAKE_BLOCK ) {
        lex_help_make_block( all_args );
    } else if ( command == XCB_COMBINE_BLOCKS ) {
        lex_help_merge_block( all_args );
    } else if ( command == XSHFB_STRIP_HEADER_FROM_BLOCK ) {
        lex_help_strip_header_from_block( all_args );
    } else if ( command == XPH_PRINT_HEADER ) {
        lex_help_print_header( all_args );
    } else if ( command == XPLI_PRINT_LIB_INFO ) {
        lex_help_print_lib_info( all_args );
    } else if ( command == XGC_GET_CAPACITY ) {
        lex_help_get_capacity( all_args );
    } else if ( command == XMSB_MAKE_STEGANOGRAPHY_BLOCK ) {
        lex_help_make_steganography_block( all_args );
    } else if ( command == XESB_EXTRACT_STEGANOGRAPHY_BLOCK ) {
        lex_help_extract_steganography_block( all_args );
    } else if ( command == XMSR_MAKE_STEGANOGRAPHY_RAW ) {
        lex_help_make_steganography_raw( all_args );
    } else if ( command == XESR_EXTRACT_STEGANOGRAPHY_RAW ) {
        lex_help_extract_steganography_raw( all_args );
    }

    lex_print_suggestions( command, all_args );
}

